import http from './http'

/**
 * 获取运动记录列表
 * @param {Object} params 查询参数
 * @returns {Promise} 运动记录列表
 */
export function getExerciseRecords(params) {
  return http.get('/api/exercise-records', { params })
}

/**
 * 分页获取运动记录
 * @param {Object} params 分页参数
 * @returns {Promise} 分页结果
 */
export function getPagedExerciseRecords(params) {
  return http.get('/api/exercise-records/paged', { params })
}

/**
 * 获取运动记录详情
 * @param {number} id 运动记录ID
 * @returns {Promise} 运动记录详情
 */
export function getExerciseRecord(id) {
  return http.get(`/api/exercise-records/${id}`)
}

/**
 * 获取指定ID的运动记录
 * @param {number} id 运动记录ID
 * @returns {Promise} 运动记录详情
 */
export function getExerciseRecordById(id) {
  console.log('API - 请求运动记录详情, ID:', id);
  
  return http.get(`/api/exercise-records/${id}`)
    .then(response => {
      // 获取实际数据（可能是response本身或response.data）
      const responseData = response.data !== undefined ? response.data : response;
      
      // 记录详细的响应信息
      console.log('API - 运动记录详情响应:', {
        响应类型: typeof response,
        数据类型: typeof responseData,
        是否有data属性: response.data !== undefined,
        日期字段: responseData ? {
          startTime: responseData.startTime,
          endTime: responseData.endTime
        } : '无响应数据'
      });
      
      // 处理日期格式（如果需要）
      if (responseData && responseData.startTime && typeof responseData.startTime === 'string' && responseData.startTime.includes('T')) {
        responseData.startTime = responseData.startTime.replace('T', ' ').substring(0, 19);
      }
      
      if (responseData && responseData.endTime && typeof responseData.endTime === 'string' && responseData.endTime.includes('T')) {
        responseData.endTime = responseData.endTime.replace('T', ' ').substring(0, 19);
      }
      
      return responseData;
    })
    .catch(error => {
      console.error('API - 获取运动记录详情失败:', {
        状态码: error.response ? error.response.status : '无状态码',
        错误信息: error.message,
        响应数据: error.response ? error.response.data : '无响应数据',
        请求ID: id
      });
      throw error;
    });
}

/**
 * 创建运动记录
 * @param {Object} data 运动记录数据
 * @returns {Promise} 创建结果
 */
export function createExerciseRecord(data) {
  console.log('API - 创建运动记录 - 原始数据:', JSON.stringify(data));
  
  // 处理日期格式和数据验证
  const processedData = { ...data };
  
  // 确保必填字段存在 - 确保兼容两种格式
  const hasExerciseType = 
    (processedData.exerciseTypeId && processedData.exerciseTypeId > 0) || 
    (processedData.exerciseType && processedData.exerciseType.id > 0);
    
  if (!hasExerciseType) {
    console.error('API - 创建记录时运动类型验证失败:', {
      exerciseTypeId: processedData.exerciseTypeId,
      exerciseType: processedData.exerciseType,
      原始数据: data
    });
    throw new Error('运动类型不能为空');
  }
  
  // 获取正确的运动类型ID，优先使用exerciseType.id
  let exerciseTypeId;
  if (processedData.exerciseType && processedData.exerciseType.id) {
    exerciseTypeId = processedData.exerciseType.id;
  } else if (processedData.exerciseTypeId) {
    exerciseTypeId = processedData.exerciseTypeId;
  }
  
  // 确保开始时间格式正确
  if (!processedData.startTime) {
    throw new Error('开始时间不能为空');
  }
  
  if (processedData.startTime && typeof processedData.startTime === 'string' && processedData.startTime.includes('T')) {
    processedData.startTime = processedData.startTime.replace('T', ' ').substring(0, 19);
  }
  
  // 确保结束时间格式正确
  if (!processedData.endTime) {
    throw new Error('结束时间不能为空');
  }
  
  if (processedData.endTime && typeof processedData.endTime === 'string' && processedData.endTime.includes('T')) {
    processedData.endTime = processedData.endTime.replace('T', ' ').substring(0, 19);
  }
  
  // 确保数值类型字段正确
  const typeId = Number(exerciseTypeId);
  const durationMinutes = Number(processedData.durationMinutes || 0);
  const caloriesBurned = Number(processedData.caloriesBurned || 0);
  
  // 限制数值范围
  const safeCalories = caloriesBurned > 10000 ? 10000 : caloriesBurned;
  const safeDuration = durationMinutes > 1440 ? 1440 : durationMinutes;
  
  if (safeDuration !== durationMinutes) {
    console.warn('API - 运动时长超过限制，已调整为1440分钟');
  }
  
  if (safeCalories !== caloriesBurned) {
    console.warn('API - 卡路里消耗超过限制，已调整为10000卡路里');
  }
  
  // 准备发送到后端的数据 - 符合ExerciseRecord实体
  const postData = {
    exerciseType: {
      id: typeId
    },
    startTime: processedData.startTime,
    endTime: processedData.endTime,
    durationMinutes: safeDuration,
    intensity: processedData.intensity || 'MEDIUM',
    location: processedData.location || "",
    notes: processedData.notes || "",
    caloriesBurned: safeCalories
  };
  
  console.log('API - 创建运动记录 - 处理后数据:', JSON.stringify(postData));
  
  return http.post('/api/exercise-records', postData)
    .then(response => {
      console.log('API - 创建运动记录成功:', response.data);
      return response;
    })
    .catch(error => {
      console.error('API - 创建运动记录失败:', {
        状态码: error.response ? error.response.status : '无状态码',
        错误信息: error.message,
        响应数据: error.response ? error.response.data : '无响应数据',
        错误详情: error.response?.data?.message || error.message
      });
      throw error;
    });
}

/**
 * 更新运动记录
 * @param {number} id 运动记录ID
 * @param {Object} data 更新数据
 * @returns {Promise} 更新结果
 */
export function updateExerciseRecord(id, data) {
  console.log('API - 更新运动记录 - 原始数据:', {
    id: id,
    数据类型: typeof data,
    数据内容: JSON.stringify(data, null, 2)
  });
  
  if (!id) {
    throw new Error('记录ID不能为空');
  }
  
  // 处理日期格式和数据验证
  const processedData = { ...data };
  
  // 确保必填字段存在 - 确保兼容两种格式
  const hasExerciseType = 
    (processedData.exerciseTypeId && processedData.exerciseTypeId > 0) || 
    (processedData.exerciseType && processedData.exerciseType.id > 0);
    
  if (!hasExerciseType) {
    console.error('API - 运动类型验证失败:', {
      exerciseTypeId: processedData.exerciseTypeId,
      exerciseType: processedData.exerciseType,
      原始数据: data
    });
    throw new Error('运动类型不能为空');
  }
  
  // 获取正确的运动类型ID
  const exerciseTypeId = processedData.exerciseTypeId || 
                       (processedData.exerciseType && processedData.exerciseType.id);
  
  // 确保开始时间格式正确
  if (!processedData.startTime) {
    throw new Error('开始时间不能为空');
  }
  
  if (processedData.startTime && typeof processedData.startTime === 'string' && processedData.startTime.includes('T')) {
    processedData.startTime = processedData.startTime.replace('T', ' ').substring(0, 19);
  }
  
  // 确保结束时间格式正确
  if (!processedData.endTime) {
    throw new Error('结束时间不能为空');
  }
  
  if (processedData.endTime && typeof processedData.endTime === 'string' && processedData.endTime.includes('T')) {
    processedData.endTime = processedData.endTime.replace('T', ' ').substring(0, 19);
  }
  
  // 确保数值类型字段正确
  const typeId = Number(exerciseTypeId);
  processedData.durationMinutes = Number(processedData.durationMinutes || 0);
  processedData.caloriesBurned = Number(processedData.caloriesBurned || 0);
  
  // 限制数值范围
  if (processedData.durationMinutes > 1440) {
    processedData.durationMinutes = 1440;
    console.warn('API - 运动时长超过限制，已调整为1440分钟');
  }
  
  if (processedData.caloriesBurned > 10000) {
    processedData.caloriesBurned = 10000;
    console.warn('API - 卡路里消耗超过限制，已调整为10000卡路里');
  }
  
  // 由于后端PUT请求的Hibernate序列化问题，改为先创建新记录再删除旧记录
  console.log('API - 使用创建新记录方式执行更新操作, 类型ID:', typeId);
  
  // 准备提交数据
  const postData = {
    exerciseType: {
      id: typeId
    },
    startTime: processedData.startTime,
    endTime: processedData.endTime,
    durationMinutes: processedData.durationMinutes,
    intensity: processedData.intensity || 'MEDIUM',
    location: processedData.location || "",
    notes: processedData.notes || "",
    caloriesBurned: processedData.caloriesBurned
  };
  
  console.log('API - 发送创建请求数据:', postData);
  
  // 先创建新记录
  return http.post('/api/exercise-records', postData)
    .then(response => {
      console.log('API - 创建新记录成功:', response);
      
      // 尝试删除旧记录
      return http.delete(`/api/exercise-records/${id}`)
        .then(() => {
          console.log('API - 旧记录删除成功, ID:', id);
          return response; // 返回创建记录的响应
        })
        .catch(deleteError => {
          console.warn('API - 旧记录删除失败，但更新操作已完成:', {
            删除错误: deleteError.message,
            记录ID: id
          });
          // 即使删除失败也返回成功，因为新记录已创建
          return response;
        });
    })
    .catch(error => {
      console.error('API - 更新操作(通过创建)失败:', {
        状态码: error.response ? error.response.status : '无状态码',
        错误信息: error.message,
        响应数据: error.response ? error.response.data : '无响应数据',
        错误详情: error.response?.data?.message || error.message
      });
      throw error;
    });
}

/**
 * 删除运动记录
 * @param {number} id 运动记录ID
 * @returns {Promise} 删除结果
 */
export function deleteExerciseRecord(id) {
  return http.delete(`/api/exercise-records/${id}`)
}

/**
 * 获取用户的运动统计数据
 * @param {Object} params 查询参数，如timeRange=WEEK|MONTH|ALL
 * @returns {Promise} 统计数据
 */
export function getExerciseStats(params) {
  return http.get('/api/exercise-records/stats', { params })
}

/**
 * 按日期范围获取运动统计数据
 * @param {string} startDate 开始日期
 * @param {string} endDate 结束日期
 * @returns {Promise} 统计数据
 */
export function getExerciseStatsByDateRange(startDate, endDate) {
  console.log('API - 请求按日期范围获取统计数据:', { startDate, endDate });
  
  // 确保日期格式正确
  let processedStartDate = startDate;
  let processedEndDate = endDate;
  
  // 处理T格式日期
  if (typeof processedStartDate === 'string' && processedStartDate.includes('T')) {
    processedStartDate = processedStartDate.replace('T', ' ').substring(0, 19);
  }
  
  if (typeof processedEndDate === 'string' && processedEndDate.includes('T')) {
    processedEndDate = processedEndDate.replace('T', ' ').substring(0, 19);
  }
  
  return http.get('/api/exercise-records/stats/date-range', {
    params: { startDate: processedStartDate, endDate: processedEndDate }
  }).then(response => {
    // 获取实际数据
    const responseData = response.data !== undefined ? response.data : response;
    
    console.log('API - 返回的统计数据:', {
      响应类型: typeof response,
      数据类型: typeof responseData,
      数据: responseData
    });
    
    return responseData;
  }).catch(error => {
    console.error('API - 获取日期范围内的统计数据失败:', {
      状态码: error.response ? error.response.status : '无状态码',
      错误信息: error.message,
      响应数据: error.response ? error.response.data : '无响应数据',
      请求参数: { startDate, endDate }
    });
    
    // 返回默认统计数据，以便UI不会崩溃
    return {
      totalRecords: 0,
      totalDuration: 0,
      totalCalories: 0,
      avgDuration: 0,
      avgCalories: 0,
      frequentTypes: [],
      intensityDistribution: {
        LOW: 0,
        MEDIUM: 0,
        HIGH: 0,
        VERY_HIGH: 0
      }
    };
  });
}

/**
 * 按运动类型获取记录
 * @param {number} typeId 运动类型ID
 * @param {Object} params 查询参数
 * @returns {Promise} 运动记录列表
 */
export function getExerciseRecordsByType(typeId, params) {
  return http.get(`/api/exercise-records/by-type/${typeId}`, { params })
}

/**
 * 获取指定日期范围内的运动记录
 * @param {string} startDate 开始日期，格式为 YYYY-MM-DD HH:mm:ss
 * @param {string} endDate 结束日期，格式为 YYYY-MM-DD HH:mm:ss
 * @returns {Promise<Array>} 运动记录列表
 */
export function getExerciseRecordsByDateRange(startDate, endDate) {
  console.log('API - 请求运动记录 - 日期范围:', { startDate, endDate });
  
  // 转换日期格式
  const formatDate = (dateStr) => {
    const date = new Date(dateStr);
    return `${date.getFullYear()}-${String(date.getMonth() + 1).padStart(2, '0')}-${String(date.getDate()).padStart(2, '0')} ${String(date.getHours()).padStart(2, '0')}:${String(date.getMinutes()).padStart(2, '0')}:${String(date.getSeconds()).padStart(2, '0')}`;
  };

  const formattedStartDate = formatDate(startDate);
  const formattedEndDate = formatDate(endDate);
  
  return http.get('/api/exercise-records/range', {
    params: { 
      startDate: formattedStartDate, 
      endDate: formattedEndDate 
    }
  }).then(response => {
    // 获取实际数据（可能是response本身或response.data）
    const responseData = response.data !== undefined ? response.data : response;
    
    // 记录详细的响应信息
    console.log('API - 运动记录详细信息:', {
      响应类型: typeof response,
      数据类型: typeof responseData,
      完整响应: response,
      是否有data属性: response.data !== undefined,
      是否为数组: Array.isArray(responseData)
    });
    
    // 处理每个记录的日期格式
    if (Array.isArray(responseData)) {
      responseData.forEach(record => {
        if (record.startTime && typeof record.startTime === 'string' && record.startTime.includes('T')) {
          record.startTime = record.startTime.replace('T', ' ').substring(0, 19);
        }
        
        if (record.endTime && typeof record.endTime === 'string' && record.endTime.includes('T')) {
          record.endTime = record.endTime.replace('T', ' ').substring(0, 19);
        }
      });
    }
    
    console.log('API - 运动记录请求成功:', {
      数据条数: Array.isArray(responseData) ? responseData.length : '未知',
      示例: Array.isArray(responseData) && responseData.length > 0 ? responseData[0] : '无数据'
    });
    
    return responseData;
  }).catch(error => {
    console.error('API - 运动记录请求失败:', {
      状态码: error.response ? error.response.status : '无状态码',
      错误信息: error.message,
      响应数据: error.response ? error.response.data : '无响应数据',
      请求参数: { startDate: formattedStartDate, endDate: formattedEndDate }
    });
    throw error;
  });
}

/**
 * 获取最近的运动记录
 * @param {number} limit 限制数量
 * @returns {Promise} 运动记录列表
 */
export function getRecentExerciseRecords(limit = 5) {
  console.log('API - 请求最近的运动记录:', { limit });
  
  // 改用查询参数方式获取最近记录，避免路由冲突
  return http.get('/api/exercise-records', { 
    params: { 
      sort: 'startTime,desc',
      size: limit 
    } 
  }).then(response => {
    const responseData = response.data !== undefined ? response.data : response;
    
    // 获取实际数据（可能是content字段或整个响应）
    let records = [];
    if (responseData && responseData.content && Array.isArray(responseData.content)) {
      records = responseData.content; // 分页响应
    } else if (Array.isArray(responseData)) {
      records = responseData; // 直接返回数组
    }
    
    console.log('API - 获取到最近记录:', {
      条数: records.length,
      示例: records.length > 0 ? records[0] : '无数据'
    });
    
    // 处理每个记录的日期格式
    records.forEach(record => {
      if (record.startTime && typeof record.startTime === 'string' && record.startTime.includes('T')) {
        record.startTime = record.startTime.replace('T', ' ').substring(0, 19);
      }
      
      if (record.endTime && typeof record.endTime === 'string' && record.endTime.includes('T')) {
        record.endTime = record.endTime.replace('T', ' ').substring(0, 19);
      }
    });
    
    return records;
  }).catch(error => {
    console.error('API - 获取最近运动记录失败:', {
      状态码: error.response ? error.response.status : '无状态码',
      错误信息: error.message,
      响应数据: error.response ? error.response.data : '无响应数据'
    });
    
    // 返回空数组避免前端崩溃
    return [];
  });
}

/**
 * 获取本周运动记录
 * @returns {Promise} 本周运动记录
 */
export function getWeeklyExerciseRecords() {
  return http.get('/api/exercise-records/weekly')
}

/**
 * 获取运动总时长
 * @param {Object} params 查询参数，如timeRange=WEEK|MONTH|ALL
 * @returns {Promise} 总时长（分钟）
 */
export function getTotalExerciseDuration(params) {
  return http.get('/api/exercise-records/total-duration', { params })
}

/**
 * 获取总消耗卡路里
 * @param {Object} params 查询参数，如timeRange=WEEK|MONTH|ALL
 * @returns {Promise} 总卡路里
 */
export function getTotalCaloriesBurned(params) {
  return http.get('/api/exercise-records/total-calories', { params })
} 